100 research outputs found
StateAFL: Greybox fuzzing for stateful network servers
Fuzzing network servers is a technical challenge, since the behavior of the
target server depends on its state over a sequence of multiple messages.
Existing solutions are costly and difficult to use, as they rely on
manually-customized artifacts such as protocol models, protocol parsers, and
learning frameworks. The aim of this work is to develop a greybox fuzzer for
network servers that only relies on lightweight analysis of the target program,
with no manual customization, in a similar way to what the AFL fuzzer achieved
for stateless programs. The proposed fuzzer instruments the target server at
compile-time, to insert probes on memory allocations and network I/O
operations. At run-time, it infers the current protocol state of the target by
analyzing snapshots of long-lived memory areas, and incrementally builds a
protocol state machine for guiding fuzzing. The experimental results show that
the fuzzer can be applied with no manual customization on a large set of
network servers for popular protocols, and that it can achieve comparable, or
even better code coverage than customized fuzzing. Moreover, our qualitative
analysis shows that states inferred from memory better reflect the server
behavior than only using response codes from messages.Comment: The tool is available at https://github.com/stateafl/stateaf
Dependability Evaluation of Middleware Technology for Large-scale Distributed Caching
Distributed caching systems (e.g., Memcached) are widely used by service
providers to satisfy accesses by millions of concurrent clients. Given their
large-scale, modern distributed systems rely on a middleware layer to manage
caching nodes, to make applications easier to develop, and to apply load
balancing and replication strategies. In this work, we performed a
dependability evaluation of three popular middleware platforms, namely
Twemproxy by Twitter, Mcrouter by Facebook, and Dynomite by Netflix, to assess
availability and performance under faults, including failures of Memcached
nodes and congestion due to unbalanced workloads and network link bandwidth
bottlenecks. We point out the different availability and performance trade-offs
achieved by the three platforms, and scenarios in which few faulty components
cause cascading failures of the whole distributed system.Comment: 2020 IEEE 31st International Symposium on Software Reliability
Engineering (ISSRE 2020
Monitoring of Aging Software Systems Affected by Integer Overflows
Numerical aging-related bugs, which can manifest themselves as the accumulation of floating-point errors and the overflow of integers, represent a known but relatively neglected issue in the field of software aging and rejuvenation. Unfortunately, it is very difficult to avoid and to fix these bugs, since the rules of computer arithmetic and programming languages are often misunderstood or disregarded by programmers. Even though software rejuvenation can potentially mitigate these problems, its adoption is prevented by the lack of approaches for forecasting numerical software aging failures: in order to efficiently plan rejuvenation, the rate of numerical errors has to be known, or at least estimated. In this paper, we focus on software aging phenomena related to integer overflows. We present some examples of integer overflow issues of the MySQL open-source DBMS, and an approach for identifying symptoms of potential integer overflows by on-line monitoring
Fault Injection Analytics: A Novel Approach to Discover Failure Modes in Cloud-Computing Systems
Cloud computing systems fail in complex and unexpected ways due to unexpected
combinations of events and interactions between hardware and software
components. Fault injection is an effective means to bring out these failures
in a controlled environment. However, fault injection experiments produce
massive amounts of data, and manually analyzing these data is inefficient and
error-prone, as the analyst can miss severe failure modes that are yet unknown.
This paper introduces a new paradigm (fault injection analytics) that applies
unsupervised machine learning on execution traces of the injected system, to
ease the discovery and interpretation of failure modes. We evaluated the
proposed approach in the context of fault injection experiments on the
OpenStack cloud computing platform, where we show that the approach can
accurately identify failure modes with a low computational cost.Comment: IEEE Transactions on Dependable and Secure Computing; 16 pages. arXiv
admin note: text overlap with arXiv:1908.1164
Olive polyphenol effects in a mouse model of chronic ethanol addiction
Objectives Alcohol addiction elicits oxidative imbalance and it is well known that polyphenols possess antioxidant properties. We investigated whether or not polyphenols could confer a protective potential against alcohol-induced oxidative stress. Methods We administered (per os) for two months 20 mg/kg of olive polyphenols containing mostly hydroxytyrosol in alcoholic adult male mice. Hydroxytyrosol metabolites as hydroxytyrosol sulfate 1 and hydroxytyrosol sulfate 2 were found in the serum of mice administered with polyphenols with the highest amount in animals treated with both polyphenols and alcohol. Oxidative stress was evaluated by FORT (free oxygen radical test) and FORD (free oxygen radical defense) tests. Results Alcoholic mice showed a worse oxidative status than nonalcoholic mice (higher FORT and lower FORD) but polyphenol supplementation partially counteracted the alcohol pro-oxidant effects, as evidenced by FORT. Conclusions A better understanding of the antioxidant protection provided by polyphenols might be of primary interest for drug discovery and dietary-based prevention of the damage associated with chronic alcohol abus
Automating the Correctness Assessment of AI-generated Code for Security Contexts
In this paper, we propose a fully automated method, named ACCA, to evaluate
the correctness of AI-generated code for security purposes. The method uses
symbolic execution to assess whether the AI-generated code behaves as a
reference implementation. We use ACCA to assess four state-of-the-art models
trained to generate security-oriented assembly code and compare the results of
the evaluation with different baseline solutions, including output similarity
metrics, widely used in the field, and the well-known ChatGPT, the AI-powered
language model developed by OpenAI. Our experiments show that our method
outperforms the baseline solutions and assesses the correctness of the
AI-generated code similar to the human-based evaluation, which is considered
the ground truth for the assessment in the field. Moreover, ACCA has a very
strong correlation with human evaluation (Pearson's correlation coefficient
r=0.84 on average). Finally, since it is a fully automated solution that does
not require any human intervention, the proposed method performs the assessment
of every code snippet in ~0.17s on average, which is definitely lower than the
average time required by human analysts to manually inspect the code, based on
our experience
Who Evaluates the Evaluators? On Automatic Metrics for Assessing AI-based Offensive Code Generators
AI-based code generators are an emerging solution for automatically writing
programs starting from descriptions in natural language, by using deep neural
networks (Neural Machine Translation, NMT). In particular, code generators have
been used for ethical hacking and offensive security testing by generating
proof-of-concept attacks. Unfortunately, the evaluation of code generators
still faces several issues. The current practice uses automatic metrics, which
compute the textual similarity of generated code with ground-truth references.
However, it is not clear what metric to use, and which metric is most suitable
for specific contexts. This practical experience report analyzes a large set of
output similarity metrics on offensive code generators. We apply the metrics on
two state-of-the-art NMT models using two datasets containing offensive
assembly and Python code with their descriptions in the English language. We
compare the estimates from the automatic metrics with human evaluation and
provide practical insights into their strengths and limitations
Enhancing Robustness of AI Offensive Code Generators via Data Augmentation
In this work, we present a method to add perturbations to the code
descriptions, i.e., new inputs in natural language (NL) from well-intentioned
developers, in the context of security-oriented code, and analyze how and to
what extent perturbations affect the performance of AI offensive code
generators. Our experiments show that the performance of the code generators is
highly affected by perturbations in the NL descriptions. To enhance the
robustness of the code generators, we use the method to perform data
augmentation, i.e., to increase the variability and diversity of the training
data, proving its effectiveness against both perturbed and non-perturbed code
descriptions
A Latency-driven Availability Assessment for Multi-Tenant Service Chains
Nowadays, most telecommunication services adhere to the Service Function Chain (SFC) paradigm, where network functions are implemented via software. In particular, container virtualization is becoming a popular approach to deploy network functions and to enable resource slicing among several tenants. The resulting infrastructure is a complex system composed by a huge amount of containers implementing different SFC functionalities, along with different tenants sharing the same chain. The complexity of such a scenario lead us to evaluate two critical metrics: the steady-state availability (the probability that a system is functioning in long runs) and the latency (the time between a service request and the pertinent response). Consequently, we propose a latency-driven availability assessment for multi-tenant service chains implemented via Containerized Network Functions (CNFs). We adopt a multi-state system to model single CNFs and the queueing formalism to characterize the service latency. To efficiently compute the availability, we develop a modified version of the Multidimensional Universal Generating Function (MUGF) technique. Finally, we solve an optimization problem to minimize the SFC cost under an availability constraint. As a relevant example of SFC, we consider a containerized version of IP Multimedia Subsystem, whose parameters have been estimated through fault injection techniques and load tests
- …